COMMENT ⊗   VALID 00003 PAGES
C REC  PAGE   DESCRIPTION
C00001 00001
C00002 00002	Structured programming is wrong in that it assumes that PROGRAMMING
C00006 00003	intro
C00008 ENDMK
C⊗;
Structured programming is wrong in that it assumes that PROGRAMMING
in data structures is difficulty, rather this domain i simple algorotithm
with complex DATA STRUCTURE. thus it is too late.

notes done before knowledge of scott , gordon, and reynolds

ideas
	richer d.s.
	parallel  ds with ops
	form valued vars
	rigid typing of parametes and results


tpoic is more ideas and less refinement

first, look at paradigm of lisp mapping to ds.

what's wrong?

too few d.s.

some hacks in mapping onto ds. e.g functions aren't really returned, only s-rep.

much of lisp programming deals really with type checking

ambit/g is neat for algorithms, but missing in usual pattern-match, replace
  easy prog--- hard ds.

ds is good for you ...static vs. dynamic

----how to do it.
bnf map to ds....in lisp, to bin. trees. 
  want to go to richer class
	3 bnf styles---three d.s primitives.

 now ambit- pattern, typing and structure. generic.
    do diff, then equal

now sequences....different operation  first simple "on"
	the extension of lit.


form-valued variables. closure, self introspection vs. self application.
	cf. REDUCE and Boyer-Moore

on hoare RDS problems of implementation if alalogous to storage for
things like int or array.   also compare type info for alternation: no constuctor,
only a predicate.


important part of d.s. rep usually ignored: i/o conventions for such; compare
list notation vs. dot notation.

don't forget fix-point approach wrt. implementation..stack-blips and seq
not just AN evaluator cna be written in language, but a REAL one can be!!!

form-valued variables and sub-tree reduction!?

g|bs|cp    good|bull shit|crack pot

basic assumption on type: it can be checked, and once checked CANNOT CHANGE.
if x is a foo at time 1, x is a foo through the life time of the l-value of x.

look at two versions of factorial and the corresponding abstract syntax of
data rep for integers.

constructions we can do without:
	coercions
	labels and gotos
	assignments
intro
   need to structure language design for proof methods
   cf syntax directed methods, fortran and algol
   must be natural

  structured programming is wrong: implies supremacy of program

  against corecion, assignment and goto,

  that lisp has the right ideas but are dirty: what to do to fix

what's wrong: paucity of d.s.
 Hoare says car-cdr
  1. simulate d.s.
  2. access across 1.
  3. tyype check

which user ds. 1 and 3 are fixed up. 2 should not be done. EVER!

bag RDS: implementation different from INT or ARRAY[...]
 note ususally think of ds. defn resulting in pred, sel, const; but
   that's wrong. 


basic ideas: 
	full typing (fuck corecion)	
	natural representation
	d.s. defn MUST be allowed to include i/o conventions; cf. list and dotted pairs

II. con-abs mapping+ eval is dirty.
   form-valued  vars and sub-tree reduction systems[?]


III languages all look like fortran; need constructs || d.s.
	should get assignment out
     AMBIT and graphical (neat)

IV implementation like eval BUT must be able to write REAL eval in
   language: cf. a-lists and eval blips.


V do it
    generic
    on

VI ascend into heaven